/**
 * 数据覆盖机制使用示例
 * 
 * 展示如何在实际Android应用中使用数据覆盖功能
 * 包括NeuroSkyService的配置、回调设置和数据处理
 * 
 * 使用场景：
 * - APK每秒向服务端发送脑波数据
 * - 服务端返回TabletBrainWaveResponse处理结果（带时间戳）
 * - 新数据自动覆盖缓存中的重复数据
 * 
 * 原理：
 * - 基于时间戳的数据去重机制
 * - 自动缓存管理和数据覆盖
 * - 实时回调通知数据更新
 * 
 * 注意：此示例已更新为使用新的TabletBrainWaveResponse模型
 */

import com.example.brain_wave.bluetooth.service.NeuroSkyService
import com.example.brain_wave.api.model.TabletBrainWaveResponse
import android.util.Log

class DataCoverageUsageExample {

    private lateinit var neuroSkyService: NeuroSkyService
    private val TAG = "DataCoverageExample"

    /**
     * 初始化数据覆盖功能
     */
    fun initializeDataCoverage() {
        neuroSkyService = NeuroSkyService()
        
        // 设置服务端数据更新回调
        neuroSkyService.setOnServerDataUpdated { responses ->
            handleServerDataUpdate(responses)
        }
        
        // 设置数据发送成功回调
        neuroSkyService.setOnDataSent { data ->
            Log.d(TAG, "数据发送成功: ${data.timestamp}")
        }
        
        // 设置错误回调
        neuroSkyService.setOnError { error ->
            Log.e(TAG, "数据处理错误: $error")
        }
        
        Log.i(TAG, "数据覆盖功能初始化完成")
    }

    /**
     * 处理服务端数据更新
     */
    private fun handleServerDataUpdate(responses: List<TabletBrainWaveResponse>) {
        Log.d(TAG, "收到服务端数据更新，共 ${responses.size} 个响应")
        
        // 处理最新数据
        val latestResponse = neuroSkyService.getLatestServerResponse()
        latestResponse?.let { response ->
            Log.d(TAG, "最新响应: 时间戳=${response.timestamp}, 睡眠阶段=${response.sleepStage}, 置信度=${response.confidence}")
            
            // 在UI中显示最新数据
            updateUI(response)
        }
        
        // 获取缓存统计信息
        val cacheSize = neuroSkyService.getServerDataCacheSize()
        Log.d(TAG, "当前缓存大小: $cacheSize")
    }

    /**
     * 更新UI显示
     */
    private fun updateUI(response: TabletBrainWaveResponse) {
        // 这里可以更新图表、显示数值等
        // 例如：更新睡眠阶段图表、显示置信度等
        Log.d(TAG, "更新UI: 睡眠阶段=${response.sleepStage}, 置信度=${response.confidence}")
    }

    /**
     * 获取历史数据进行分析
     */
    fun analyzeHistoricalData() {
        val allResponses = neuroSkyService.getAllServerResponses()
        
        if (allResponses.isNotEmpty()) {
            Log.d(TAG, "开始分析历史数据，共 ${allResponses.size} 个响应")
            
            // 按睡眠阶段分组分析
            val groupedData = allResponses.groupBy { it.sleepStage }
            
            groupedData.forEach { (stage, responses) ->
                val averageConfidence = responses.mapNotNull { it.confidence }.average()
                Log.d(TAG, "睡眠阶段 $stage 的平均置信度: $averageConfidence")
            }
            
            // 分析数据趋势
            analyzeTrend(allResponses)
        } else {
            Log.w(TAG, "没有历史数据可供分析")
        }
    }

    /**
     * 分析数据趋势
     */
    private fun analyzeTrend(responses: List<TabletBrainWaveResponse>) {
        if (responses.size < 2) return
        
        val sortedResponses = responses.sortedBy { it.timestamp }
        val firstConfidence = sortedResponses.first().confidence ?: 0f
        val lastConfidence = sortedResponses.last().confidence ?: 0f
        
        val trend = when {
            lastConfidence > firstConfidence -> "上升"
            lastConfidence < firstConfidence -> "下降"
            else -> "稳定"
        }
        
        Log.d(TAG, "置信度趋势: $trend (从 $firstConfidence 到 $lastConfidence)")
    }

    /**
     * 清理缓存数据
     */
    fun clearCache() {
        neuroSkyService.clearServerDataCache()
        Log.d(TAG, "缓存数据已清理")
    }

    /**
     * 获取实时数据统计
     */
    fun getRealtimeStats(): Map<String, Any> {
        val cacheSize = neuroSkyService.getServerDataCacheSize()
        val latestResponse = neuroSkyService.getLatestServerResponse()
        
        return mapOf(
            "cacheSize" to cacheSize,
            "hasLatestResponse" to (latestResponse != null),
            "latestTimestamp" to (latestResponse?.timestamp ?: 0L),
            "latestSleepStage" to (latestResponse?.sleepStage ?: "unknown"),
            "latestConfidence" to (latestResponse?.confidence ?: 0f)
        )
    }

    /**
     * 示例：在Activity中的使用方法
     */
    fun exampleUsageInActivity() {
        // 在Activity的onCreate中调用
        initializeDataCoverage()
        
        // 定期获取统计信息（例如每5秒）
        // Timer().scheduleAtFixedRate(object : TimerTask() {
        //     override fun run() {
        //         val stats = getRealtimeStats()
        //         Log.d(TAG, "实时统计: $stats")
        //     }
        // }, 0, 5000)
        
        // 在需要时分析历史数据
        // analyzeHistoricalData()
        
        // 在Activity销毁时清理资源
        // clearCache()
    }
}